home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Aminet 2
/
Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso
/
Aminet
/
game
/
role
/
larn.zoo
/
vms.c
< prev
next >
Wrap
C/C++ Source or Header
|
1991-04-28
|
7KB
|
234 lines
#ifdef VMS
#include "header.h"
#include <file.h>
#include <stat.h>
#include <stdio.h>
#include <stsdef.h>
#include <ssdef.h>
#include <descrip.h>
#include <iodef.h>
#include <ttdef.h>
#include <tt2def.h>
/*
* Read until end of file or until buffer is full.
* don't let the vms read (which stops once per record)
* fool the program.
*/
vread(fd, buf, size)
int fd;
char *buf;
int size;
{
int csize; /* cumulative size */
int isize; /* incremental size */
csize = 0;
do {
isize = read(fd, buf, size);
if (isize > 0) {
csize += isize;
buf += isize;
size -= isize;
}
} while (isize > 0);
return (csize);
}
#else VMS
#ifndef vread /* if not done as a macro in header.h */
vread(fd, buf, size)
int fd;
char *buf;
int size;
{
return (read(fd, buf, size));
}
#endif vread
#endif VMS
#ifdef VMS
/*
* Run a command in a subjob. Used for mailing the winners congratulations,
* tax bills, etc. Used for the shell escape command (!). Conditionalized
* for VMS wherever used (un*x has the right primitives).
*/
long
oneliner(cstr)
char *cstr;
{
struct dsc$descriptor cdsc;
register long sts;
register long pstat;
cdsc.dsc$a_pointer = cstr;
cdsc.dsc$w_length = strlen(cstr);
cdsc.dsc$b_dtype = DSC$K_DTYPE_T;
cdsc.dsc$b_class = DSC$K_CLASS_S;
sts = LIB$SPAWN(&cdsc, 0, 0, 0, 0, 0, &pstat, 0, 0, 0, 0, 0);
if (sts != SS$_NORMAL)
return (sts);
else
return (pstat);
}
/*
Data to convert the escape codes produced by VT style keypad keys to things
that LARN will understand.
*/
#define MAX_KP_CONV 19
struct
{
char *inp_str;
char *out_str;
} keypad_conv[MAX_KP_CONV] = { { "\x1BOp", "i" }, /* KP0 */
{ "\x1BOq", "b" }, /* KP1 */
{ "\x1BOr", "j" }, /* KP2 */
{ "\x1BOs", "n" }, /* KP3 */
{ "\x1BOt", "h" }, /* KP4 */
{ "\x1BOu", "." }, /* KP5 */
{ "\x1BOv", "l" }, /* KP6 */
{ "\x1BOw", "y" }, /* KP7 */
{ "\x1BOx", "k" }, /* KP8 */
{ "\x1BOy", "u" }, /* KP9 */
{ "\x1BOn", "." }, /* KP. */
{ "\x1BOl", "," }, /* KP, */
{ "\x1B[A", "K" }, /* uparrow */
{ "\x1B[B", "J" }, /* downarrow*/
{ "\x1B[C", "L" }, /* right arrow */
{ "\x1B[D", "H" }, /* left arrow */
{ "\x1BOP", "m" }, /* PF1 */
{ "\x1BOS", "@" }, /* PF4 */
{ "\x1B[23~", "\x1B" } /* (ESC) */
};
/*
VMS-specific terminal character read. Gets a character from the terminal,
translating keypad as necessary. Assumes VT-class terminals.
*/
vms_ttgetch()
{
#define BUFFLEN 10
char *i;
int j;
register int incount;
static char buffer[BUFFLEN];
static char *bufptr = buffer;
static char *bufend = buffer;
lflush(); /* be sure output buffer is flushed */
/* Read the first char from the user
*/
if (bufptr >= bufend)
{
bufptr = bufend = buffer;
incount = vmsread(buffer, BUFFLEN, 0);
while ( incount <= 0 )
incount = vmsread(buffer, 1, 2);
bufend = &buffer[incount];
}
/* If the first char was an ESCAPE, get the characters from an
escape sequence (eg pressing a key that generates such a
sequence). If it was a plain old escape, the vmsread() call
will return TIMEOUT.
*/
if (*bufptr == '\x1B' )
{
incount = vmsread( bufend, (BUFFLEN - 1), 0 );
if (incount >= 0)
bufend += incount ;
}
/* Make sure the buffer is zero-terminated, since vmsread()
doesn't zero-terminate the characters read.
*/
*bufend = '\0' ;
/* run through the keypad conversion table to convert keypad
keys (escape sequences) and other supported escape sequences
to Larn command characters.
*/
for ( j = 0; j < MAX_KP_CONV ; j++ )
if (strcmp( &buffer, keypad_conv[j].inp_str ) == 0 )
{
strcpy( &buffer, keypad_conv[j].out_str );
bufend = &buffer[strlen(&buffer)];
break;
}
/* If after running through the table the first character is still
ESCAPE, then we probably didn't get a match. Force unsupported
keys that generate escape sequences to just return an ESCAPE.
Effectively prevents key translations that generate escape
sequences.
*/
if (*bufptr == '\x1B' )
{
bufend = &buffer[1] ;
}
*bufend = '\0' ;
if (*bufptr == '\r')
*bufptr = '\n';
return (*bufptr++ & 0xFF);
}
typedef struct
{
short int status;
short int term_offset;
short int terminator;
short int term_size;
} IOSTAB;
int vmsread(buffer, size, timeout)
char *buffer;
int size;
int timeout;
{
#define TIMEOUT (-2)
#define ERROR (-1)
extern int iochan;
register int status;
IOSTAB iostab;
static long termset[2] = { 0, 0 }; /* No terminator */
status = SYS$QIOW(
0, /* Event flag */
iochan, /* Input channel */
IO$_READLBLK | IO$M_NOFILTR | IO$M_TIMED,
/* Read, no echo, no translate */
&iostab, /* I/O status block */
NULL, /* AST block (none) */
0, /* AST parameter */
buffer, /* P1 - input buffer */
size, /* P2 - buffer length */
timeout, /* P3 - timeout */
&termset, /* P4 - terminator set */
NULL, /* P5 - ignored (prompt buffer) */
0 /* P6 - ignored (prompt size) */
);
if (status == SS$_TIMEOUT)
return (TIMEOUT);
else if (status != SS$_NORMAL)
return (ERROR);
else
{
if ((status = iostab.term_offset + iostab.term_size) > 0)
return (status);
return (TIMEOUT);
}
}
#endif VMS